home *** CD-ROM | disk | FTP | other *** search
/ Windows Expert / Windows Expert.iso / sound / audiocd.zip / CD_CMDS.C < prev    next >
C/C++ Source or Header  |  1992-10-24  |  8KB  |  282 lines
  1. /***********************************************************************/
  2. /* Simple CD Player --- 24 October 1992                                */
  3. /* This module provides the CD commands.                               */
  4. /*                                                                     */
  5. /* Written by John A. Junod using code ideas presented in the SDK      */
  6. /* documentation.                                                      */
  7. /*                                                                     */
  8. /* Modify this as much as you wish and redistribute however you wish,  */
  9. /* but I do ask that you give me some of the credit and that you let   */
  10. /* other people use the final product for FREE and don't charge some   */
  11. /* silly shareware fee of $25.                                         */
  12. /***********************************************************************/
  13.  
  14. #include "cd.h"
  15.  
  16. extern HWND hMainWnd;
  17. extern char szBuffer[];
  18. extern HCURSOR hHourGlass;
  19. extern BOOL bCanEject;
  20.  
  21. DWORD CD_GetDeviceInfo(UINT wDeviceID) {
  22.     HCURSOR hSaveCursor;
  23.     DWORD dwReturn;
  24.     MCI_GETDEVCAPS_PARMS mciGDCparms;
  25.     MCI_STATUS_PARMS mciStatusParms;
  26.  
  27.     WAITON();
  28.     // can this drive eject?
  29.     mciGDCparms.dwItem=MCI_GETDEVCAPS_CAN_EJECT;
  30.     if(dwReturn=mciSendCommand(wDeviceID,MCI_GETDEVCAPS,
  31.             MCI_GETDEVCAPS_ITEM,
  32.             (DWORD)(LPVOID)&mciGDCparms)) {
  33.         WAITOFF();
  34.         return(dwReturn);
  35.     }
  36.     bCanEject=mciGDCparms.dwReturn;
  37.     mciStatusParms.dwItem=MCI_STATUS_MEDIA_PRESENT;
  38.     if(dwReturn=mciSendCommand(wDeviceID,MCI_STATUS,
  39.             MCI_STATUS_ITEM,
  40.             (DWORD)(LPVOID)&mciStatusParms)) {
  41.         WAITOFF();
  42.         return(dwReturn);
  43.     }
  44.     WAITOFF();
  45.     if(!(mciStatusParms.dwReturn))
  46.         MessageBox(hMainWnd,"No media present.","CD Audio Player",MB_OK);
  47.     return(0L);
  48. }
  49.  
  50. DWORD CD_ShowTrackTimes(UINT wDeviceID,LPSTR szTimeString) {
  51.     HCURSOR hSaveCursor;
  52.     int i, iNumTracks, iStatus;
  53.     DWORD dwReturn;
  54.     DWORD dwPosition;
  55.     DWORD *pMem;
  56.     char szTempString[64];
  57.     MCI_SET_PARMS mciSetParms;
  58.     MCI_STATUS_PARMS mciStatusParms;
  59.  
  60.  
  61.     WAITON();
  62.  
  63.     // set time format to minute/second/frame
  64.     mciSetParms.dwTimeFormat=MCI_FORMAT_MSF;
  65.     if(dwReturn=mciSendCommand(wDeviceID,MCI_SET,MCI_SET_TIME_FORMAT,
  66.         (DWORD)(LPVOID)&mciSetParms)) {
  67.         WAITOFF();
  68.         return(dwReturn);
  69.     }
  70.     // get number of tracks (limit to 20)
  71.     mciStatusParms.dwItem=MCI_STATUS_NUMBER_OF_TRACKS;
  72.     if(dwReturn=mciSendCommand(wDeviceID,MCI_STATUS,MCI_STATUS_ITEM,
  73.         (DWORD)(LPVOID)&mciStatusParms)) {
  74.         WAITOFF();
  75.         return(dwReturn);
  76.     }
  77.     iNumTracks=mciStatusParms.dwReturn;
  78.     wsprintf(szTimeString,"  CD Player\nJohn A. Junod\nTracks: %2d\n",
  79.         iNumTracks);
  80.     // iNumTracks=min(iNumTracks,20);
  81.  
  82.     // get device status
  83.     mciStatusParms.dwItem=MCI_STATUS_MODE;
  84.     if((dwReturn=mciSendCommand(wDeviceID,MCI_STATUS,MCI_STATUS_ITEM,
  85.             (DWORD)(LPVOID)&mciStatusParms))==0L) {
  86.         iStatus=mciStatusParms.dwReturn;
  87.         wsprintf(szTempString,"Status: %d\nEject: %d\n",iStatus,bCanEject);
  88.         lstrcat(szTimeString,szTempString);
  89.  
  90.         // alloc memory for start
  91.         if((pMem=(DWORD *)LocalAlloc(LPTR,iNumTracks*sizeof(DWORD)))!=NULL) {
  92.             // for each track, get and save start position and build string
  93.             for(i=1;i<=iNumTracks;i++) {
  94.                 mciStatusParms.dwItem=MCI_STATUS_LENGTH;
  95.                 mciStatusParms.dwTrack=i;
  96.                 if(dwReturn=mciSendCommand(wDeviceID,MCI_STATUS,
  97.                         MCI_STATUS_ITEM | MCI_TRACK, (DWORD)(LPVOID)&mciStatusParms)) {
  98.                     LocalFree((HANDLE)pMem);
  99.                     WAITOFF();
  100.                     return(dwReturn);
  101.                 }
  102.                 pMem[i-1]=mciStatusParms.dwReturn;
  103.                 wsprintf(szTempString,"Track %2d - %02d:%02d:%02d\n",
  104.                     i,MCI_MSF_MINUTE(pMem[i-1]), MCI_MSF_SECOND(pMem[i-1]),
  105.                     MCI_MSF_FRAME(pMem[i-1]));
  106.                 lstrcat(szTimeString,szTempString);
  107.             }
  108.             // display results
  109.             MessageBox(hMainWnd,szTimeString,"Track Times",
  110.                 MB_OK);
  111.             // free memory and close device
  112.             LocalFree((HANDLE)pMem);
  113.             dwReturn=0L;
  114.         } else dwReturn= -1L; // pMem failed
  115.     }
  116.     WAITOFF();
  117.     return(dwReturn);
  118. }
  119.  
  120. int CD_GetCurrentTrack(UINT wDeviceID) {
  121.     DWORD dwReturn;
  122.     int iCurrentTrack;
  123.     MCI_SET_PARMS mciSetParms;
  124.     MCI_STATUS_PARMS mciStatusParms;
  125.  
  126.     // set time format to minute/second/frame
  127.     mciSetParms.dwTimeFormat=MCI_FORMAT_MSF;
  128.     if(dwReturn=mciSendCommand(wDeviceID,MCI_SET,MCI_SET_TIME_FORMAT,
  129.             (DWORD)(LPVOID)&mciSetParms))
  130.         iCurrentTrack= -1;
  131.     else {
  132.         // get current track that we are playing
  133.         mciStatusParms.dwItem=MCI_STATUS_CURRENT_TRACK;
  134.         if(dwReturn=mciSendCommand(wDeviceID,MCI_STATUS,
  135.                 MCI_STATUS_ITEM,
  136.                 (DWORD)(LPVOID)&mciStatusParms))
  137.             iCurrentTrack= -1;
  138.         else
  139.             iCurrentTrack=mciStatusParms.dwReturn;
  140.     }
  141. //    if(iCurrentTrack== -1) showMCIError(dwReturn);
  142.     return(iCurrentTrack);
  143. }
  144.  
  145. int CD_GetCurrentStatus(UINT wDeviceID) {
  146.     DWORD dwReturn;
  147.     MCI_STATUS_PARMS mciStatusParms;
  148.     int iRetCode;
  149.  
  150.     iRetCode=0;
  151.     mciStatusParms.dwItem=MCI_STATUS_MODE;
  152.     if(dwReturn=mciSendCommand(wDeviceID,MCI_STATUS,MCI_STATUS_ITEM,
  153.             (DWORD)(LPVOID)&mciStatusParms)) {
  154.         iRetCode= -1;
  155.     } else {
  156.         switch(mciStatusParms.dwReturn) {
  157.             case MCI_MODE_PLAY:     iRetCode=1; break;
  158.             case MCI_MODE_PAUSE: iRetCode=2; break;
  159.             case MCI_MODE_OPEN:  iRetCode=4; break;
  160.             case MCI_MODE_SEEK:  iRetCode=3; break;
  161.             case MCI_MODE_NOT_READY: iRetCode=3; break;
  162.         }
  163.     }
  164. //    if(iRetCode== -1) showMCIError(dwReturn);
  165.     return(iRetCode);
  166. }
  167.  
  168. // play a given cdaudio track
  169. DWORD CD_PlayTrack(UINT wDeviceID,BYTE bStartTrack,BYTE bEndTrack)
  170. {
  171.     HCURSOR hSaveCursor;
  172.     DWORD dwParams;
  173.     DWORD dwReturn;
  174.     MCI_SET_PARMS mciSetParms;
  175.     MCI_PLAY_PARMS mciPlayParms;
  176.  
  177.     WAITON();
  178.     // set time format to track/minute/second/frame
  179.     mciSetParms.dwTimeFormat=MCI_FORMAT_TMSF;
  180.     if(dwReturn=mciSendCommand(wDeviceID,MCI_SET,MCI_SET_TIME_FORMAT,
  181.             (DWORD)(LPVOID)&mciSetParms))
  182.     {
  183.         WAITOFF();
  184.         return(dwReturn);
  185.     }
  186.  
  187.     // notify on completion
  188.     dwParams=MCI_NOTIFY;
  189.     mciPlayParms.dwCallback=(DWORD)hMainWnd;
  190.     // if start is not specified, we pick up where we left off
  191.     if(bStartTrack>0) dwParams |= MCI_FROM;
  192.     mciPlayParms.dwFrom=MCI_MAKE_TMSF(bStartTrack,0,0,0);
  193.     // if end is not specified, we play the rest of the cd
  194.     if(bEndTrack>bStartTrack) dwParams |= MCI_TO;
  195.     mciPlayParms.dwTo  =MCI_MAKE_TMSF(bEndTrack,0,0,0);
  196.     // execute the command
  197.     dwReturn=mciSendCommand(wDeviceID,MCI_PLAY,
  198.             dwParams,(DWORD)(LPVOID) &mciPlayParms);
  199.     WAITOFF();
  200.     return(dwReturn);
  201. }
  202.  
  203. // pause cdaudio
  204. DWORD CD_Pause(UINT wDeviceID) {
  205.     HCURSOR hSaveCursor;
  206.     DWORD dwReturn;
  207.     MCI_GENERIC_PARMS mciGenericParms;
  208.  
  209.     WAITON();
  210.     mciGenericParms.dwCallback=(DWORD)hMainWnd;
  211.     dwReturn=mciSendCommand(wDeviceID,MCI_PAUSE,MCI_NOTIFY,
  212.         (DWORD)(LPVOID)&mciGenericParms);
  213.     WAITOFF();
  214.     return(dwReturn);
  215. }
  216.  
  217. DWORD CD_ResumePlay(UINT wDeviceID){
  218.     HCURSOR hSaveCursor;
  219.     DWORD dwReturn;
  220.     MCI_GENERIC_PARMS mciGenericParms;
  221.     MCI_PLAY_PARMS    mciPlayParms;
  222.  
  223.     WAITON();
  224.     mciGenericParms.dwCallback=(DWORD)hMainWnd;
  225.     mciPlayParms.dwCallback   =(DWORD)hMainWnd;
  226.     // attempt a resume command, if it fails (device doesn't support it),
  227.     // then do a play with no parameters.
  228.     if(dwReturn=mciSendCommand(wDeviceID,MCI_RESUME,MCI_NOTIFY,
  229.         (DWORD)(LPVOID)&mciGenericParms))
  230.         dwReturn=mciSendCommand(wDeviceID,MCI_PLAY,MCI_NOTIFY,
  231.             (DWORD)(LPVOID)&mciPlayParms);
  232.     WAITOFF();
  233.     return(dwReturn);
  234. }
  235.  
  236. DWORD CD_Stop(UINT wDeviceID){
  237.     HCURSOR hSaveCursor;
  238.     DWORD dwReturn;
  239.     MCI_GENERIC_PARMS mciGenericParms;
  240.  
  241.     WAITON();
  242.     mciGenericParms.dwCallback=(DWORD)hMainWnd;
  243.     dwReturn=mciSendCommand(wDeviceID,MCI_STOP,MCI_NOTIFY,
  244.             (DWORD)(LPVOID)&mciGenericParms);
  245.     WAITOFF();
  246.     return(dwReturn);
  247. }
  248.  
  249. DWORD CD_Open(UINT wDeviceID){
  250.     HCURSOR hSaveCursor;
  251.     DWORD dwReturn;
  252.     MCI_SET_PARMS mciSetParms;
  253.  
  254.     WAITON();
  255.     mciSetParms.dwCallback=(DWORD)hMainWnd;
  256.     dwReturn=mciSendCommand(wDeviceID,MCI_SET_DOOR_OPEN,MCI_NOTIFY,
  257.             (DWORD)(LPVOID)&mciSetParms);
  258.     WAITOFF();
  259.     return(dwReturn);
  260. }
  261.  
  262. DWORD CD_Close(UINT wDeviceID){
  263.     HCURSOR hSaveCursor;
  264.     DWORD dwReturn;
  265.     MCI_SET_PARMS mciSetParms;
  266.  
  267.     WAITON();
  268.     mciSetParms.dwCallback=(DWORD)hMainWnd;
  269.     dwReturn=mciSendCommand(wDeviceID,MCI_SET_DOOR_CLOSED,MCI_NOTIFY,
  270.             (DWORD)(LPVOID)&mciSetParms);
  271.     WAITOFF();
  272.     return(dwReturn);
  273. }
  274.  
  275. DWORD CD_ChangeTrack(UINT wDeviceID,int iNoffs) {
  276.     int iNewTrack;
  277.  
  278.     iNewTrack=CD_GetCurrentTrack(wDeviceID)+iNoffs;
  279.     if(iNewTrack<1) return(0L);
  280.     return(CD_PlayTrack(wDeviceID,iNewTrack,0));
  281. }
  282.